WebDriver with Python is a powerful approach for automating web browsers and testing web applications using Python programming language and Selenium WebDriver. Selenium WebDriver allows Python programs to control browsers such as Chrome, Firefox, Edge, and Safari, perform user-like actions, locate web elements, validate application behavior, and execute automated test cases.
Python provides a simple and readable programming syntax, while Selenium WebDriver provides browser automation capabilities. Together, they are widely used for web application testing, regression testing, functional testing, smoke testing, end-to-end testing, and automation framework development.
For structured Selenium learning, explore Selenium Training and Register for Course Demo.
Selenium WebDriver is a browser automation technology that allows programs to communicate directly with web browsers and perform actions similar to a real user.
Using WebDriver with Python, a tester can open a browser, navigate to a website, find elements, enter text, click buttons, select options, handle alerts, switch between frames and windows, capture screenshots, and verify expected results.
WebDriver is one of the major components of the Selenium project and is primarily used for automating web applications.
from selenium import webdriver
driver = webdriver.Chrome()
driver.get("https://example.com")
print(driver.title)
driver.quit()
Python is a high-level, interpreted programming language known for its readable syntax and extensive library ecosystem. In Selenium automation, Python is used to write test scripts that communicate with browsers through Selenium WebDriver.
Important Python concepts used in Selenium automation include:
Python makes Selenium automation easier to learn and maintain because of its simple syntax and large ecosystem.
| Feature | Benefit |
|---|---|
| Simple Syntax | Automation scripts are easy to read and understand. |
| Fast Development | Test scripts can be created quickly. |
| Large Ecosystem | Python provides many testing and automation libraries. |
| pytest Support | Automation tests can be organized and executed using pytest. |
| Cross-Platform | Python automation can run on Windows, macOS, and Linux. |
| Reusable Code | Functions, classes, modules, and Page Object Model can be used. |
| Easy Debugging | Readable code makes debugging easier. |
The basic relationship between Python, Selenium, WebDriver, and the browser can be represented as:
Python Test Script
|
v
Selenium Python Library
|
v
WebDriver
|
v
Browser Driver / Selenium Manager
|
v
Chrome / Firefox / Edge / Safari
|
v
Web Application
The Python test script sends commands through the Selenium Python package. WebDriver communicates with the browser and performs the requested operations.
The Selenium project consists of multiple tools and technologies.
| Component | Description |
|---|---|
| Selenium WebDriver | Automates browsers programmatically. |
| Selenium IDE | Provides browser-based record-and-playback capabilities. |
| Selenium Grid | Supports remote and distributed test execution. |
For Python automation, Selenium WebDriver is the primary component used.
Before using Selenium with Python, Python should be installed on the system.
After installation, verify the Python version from the terminal or command prompt.
python --versionOn some systems, the following command may be required:
python3 --versionPython 3.x.xpip is Python's package installer. It is used to install Selenium and other Python packages.
pip --versionIf the system uses pip3, use:
pip3 --versionSelenium can be installed using pip.
pip install seleniumFor systems where Python 3 is explicitly invoked:
pip3 install seleniumAfter installation, Selenium can be imported into a Python program.
from selenium import webdriverA virtual environment creates an isolated Python environment for a project. It prevents project dependencies from interfering with packages installed for other projects.
python -m venv venvvenv\Scripts\activatesource venv/bin/activatepip install seleniumThe Selenium WebDriver module can be imported using:
from selenium import webdriverThe webdriver module provides browser-specific WebDriver classes such as Chrome, Firefox, Edge, and Safari.
Chrome automation can be started using webdriver.Chrome().
from selenium import webdriver
driver = webdriver.Chrome()
driver.get("https://example.com")
print(driver.title)
driver.quit()
Modern Selenium versions include Selenium Manager, which can assist with browser driver management in supported environments.
from selenium import webdriver
driver = webdriver.Edge()
driver.get("https://example.com")
print(driver.title)
driver.quit()
from selenium import webdriver
driver = webdriver.Firefox()
driver.get("https://example.com")
print(driver.title)
driver.quit()
Safari WebDriver is primarily used on macOS systems.
from selenium import webdriver
driver = webdriver.Safari()
driver.get("https://example.com")
print(driver.title)
driver.quit()
The following program opens Chrome, navigates to a website, displays the page title, and closes the browser.
from selenium import webdriver
driver = webdriver.Chrome()
driver.get("https://example.com")
print("Page Title:", driver.title)
driver.quit()
Start
|
v
Create WebDriver
|
v
Open Browser
|
v
Open Website
|
v
Read Page Title
|
v
Close Browser
|
v
End
The WebDriver object represents the browser session controlled by the Python program.
driver = webdriver.Chrome()Once the object is created, various browser operations can be performed.
driver.get("https://example.com")
driver.refresh()
driver.back()
driver.forward()
driver.quit()
The get() method navigates the browser to a specified URL.
driver.get("https://example.com")Example:
from selenium import webdriver
driver = webdriver.Chrome()
driver.get("https://www.google.com")
driver.quit()
Web applications contain elements such as text boxes, buttons, links, checkboxes, dropdowns, images, and forms. Selenium uses locators to identify these elements.
Common Selenium locators include:
The By class provides standard locator strategies for finding web elements.
from selenium.webdriver.common.by import By| Locator | Python Syntax |
|---|---|
| ID | By.ID |
| Name | By.NAME |
| Class Name | By.CLASS_NAME |
| Tag Name | By.TAG_NAME |
| Link Text | By.LINK_TEXT |
| Partial Link Text | By.PARTIAL_LINK_TEXT |
| CSS Selector | By.CSS_SELECTOR |
| XPath | By.XPATH |
ID is generally a convenient locator when an element has a unique and stable ID.
from selenium.webdriver.common.by import By
username = driver.find_element(By.ID, "username")
username.send_keys("admin")
email = driver.find_element(By.NAME, "email")
email.send_keys("[email protected]")
button = driver.find_element(By.CLASS_NAME, "login-button")
button.click()
links = driver.find_elements(By.TAG_NAME, "a")
for link in links:
print(link.text)
login_link = driver.find_element(By.LINK_TEXT, "Login")
login_link.click()
link = driver.find_element(By.PARTIAL_LINK_TEXT, "Log")
link.click()
CSS selectors provide a flexible way to locate elements using HTML attributes, classes, IDs, hierarchy, and other selector patterns.
search_box = driver.find_element(By.CSS_SELECTOR, "#search")
search_box.send_keys("Selenium")
button = driver.find_element(By.CSS_SELECTOR, "button.login")
button.click()
XPath can locate elements based on their structure, attributes, text, and relationships with other elements.
username = driver.find_element(By.XPATH, "//input[@id='username']")
username.send_keys("admin")
button = driver.find_element(By.XPATH, "//button[text()='Login']")
button.click()
find_element() returns a single matching web element. If Selenium cannot find the element, an exception can be raised.
element = driver.find_element(By.ID, "username")
element.click()
find_elements() returns a collection of matching elements.
links = driver.find_elements(By.TAG_NAME, "a")
for link in links:
print(link.text)
| Method | Result |
|---|---|
| find_element() | Returns one matching element. |
| find_elements() | Returns a collection of matching elements. |
A WebElement represents an HTML element located by Selenium.
Common WebElement operations include:
The send_keys() method enters keyboard input into an element.
username = driver.find_element(By.ID, "username")
username.send_keys("admin")
The click() method performs a click action on an element.
login_button = driver.find_element(By.ID, "login")
login_button.click()
The clear() method removes existing text from an editable field.
search_box = driver.find_element(By.ID, "search")
search_box.clear()
search_box.send_keys("Selenium")
message = driver.find_element(By.ID, "message")
print(message.text)
element = driver.find_element(By.ID, "submit")
print(element.is_displayed())
print(element.is_enabled())
print(element.is_selected())
Selenium WebDriver provides browser navigation methods.
driver.get("https://example.com")
driver.back()
driver.forward()
driver.refresh()
| Method | Purpose |
|---|---|
| get() | Open a URL. |
| back() | Move to the previous page. |
| forward() | Move to the next page. |
| refresh() | Reload the current page. |
WebDriver provides properties that allow the test to retrieve information about the current browser session.
print(driver.title)
print(driver.current_url)
print(driver.current_window_handle)
The browser window can be controlled using WebDriver window methods.
driver.maximize_window()
driver.minimize_window()
A fixed browser size can also be configured when required by a test environment.
| Method | Purpose |
|---|---|
| close() | Closes the current browser window or tab. |
| quit() | Ends the WebDriver session and closes associated browser windows. |
For complete test cleanup, driver.quit() is generally preferred.
A finally block can be used to ensure the browser session is closed even if an exception occurs.
from selenium import webdriver
driver = webdriver.Chrome()
try:
driver.get("https://example.com")
print(driver.title)
finally:
driver.quit()
Selenium provides exceptions that help identify problems during browser automation.
Common exceptions include:
Python's try-except statement can be used to handle Selenium exceptions.
from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException
driver = webdriver.Chrome()
try:
driver.get("https://example.com")
element = driver.find_element(By.ID, "missing")
except NoSuchElementException:
print("Element was not found.")
finally:
driver.quit()
Modern web applications often load elements dynamically. An explicit wait allows Selenium to wait for a specific condition instead of immediately trying to interact with an element.
from selenium.webdriver.support.ui import WebDriverWait
wait = WebDriverWait(driver, 10)
Expected Conditions provide commonly used conditions for explicit waits.
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
wait = WebDriverWait(driver, 10)
login_button = wait.until(
EC.element_to_be_clickable((By.ID, "login"))
)
login_button.click()
An implicit wait instructs WebDriver to wait for a specified amount of time when searching for elements.
driver.implicitly_wait(10)Implicit waits should be used thoughtfully because they apply globally to element searches.
| Implicit Wait | Explicit Wait |
|---|---|
| Applies globally to element searches. | Targets a specific condition. |
| Simple to configure. | More precise. |
| Less flexible. | Highly flexible. |
| Useful for general synchronization. | Useful for dynamic application behavior. |
The ActionChains class is used for advanced mouse and keyboard interactions.
from selenium.webdriver.common.action_chains import ActionChains
actions = ActionChains(driver)
menu = driver.find_element(By.ID, "menu")
ActionChains(driver).move_to_element(menu).perform()
element = driver.find_element(By.ID, "item")
ActionChains(driver).double_click(element).perform()
element = driver.find_element(By.ID, "item")
ActionChains(driver).context_click(element).perform()
source = driver.find_element(By.ID, "source")
target = driver.find_element(By.ID, "target")
ActionChains(driver).drag_and_drop(source, target).perform()
The Selenium Select class can be used for standard HTML select elements.
from selenium.webdriver.support.ui import Select
dropdown = driver.find_element(By.ID, "country")
select = Select(dropdown)
select.select_by_visible_text("India")select.select_by_value("IN")select.select_by_index(1)Selenium can switch to browser alerts using the alert object.
alert = driver.switch_to.alert
print(alert.text)
alert.accept()
alert.dismiss()alert.send_keys("Test")
alert.accept()
When an element is located inside an iframe, Selenium must switch to that frame before interacting with the element.
driver.switch_to.frame("frame_name")
element = driver.find_element(By.ID, "username")
element.send_keys("admin")
driver.switch_to.default_content()
Selenium provides window handles for identifying browser windows and tabs.
original_window = driver.current_window_handle
print(driver.window_handles)
After a new window or tab is opened, Selenium can switch to it.
for window in driver.window_handles:
if window != original_window:
driver.switch_to.window(window)
break
Screenshots are useful for debugging failed automation tests and maintaining test evidence.
driver.save_screenshot("homepage.png")Screenshot functionality can also be added to exception handling and test reporting workflows.
Selenium can read, add, and delete browser cookies.
cookies = driver.get_cookies()
for cookie in cookies:
print(cookie)
driver.add_cookie({
"name": "test_cookie",
"value": "12345"
})
driver.delete_cookie("test_cookie")driver.delete_all_cookies()Selenium allows JavaScript code to be executed inside the current browser context.
driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")title = driver.execute_script("return document.title;")
print(title)
JavaScript execution should generally be used when normal WebDriver interactions are insufficient or when a specific browser-side operation is required.
Browser options allow automation behavior to be configured before creating the WebDriver instance.
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
options = Options()
options.add_argument("--start-maximized")
driver = webdriver.Chrome(options=options)
driver.get("https://example.com")
driver.quit()
options = Options()
options.add_argument("--headless")
driver = webdriver.Chrome(options=options)
Remote WebDriver allows tests to communicate with a WebDriver server or remote browser infrastructure.
from selenium import webdriver
driver = webdriver.Remote(
command_executor="http://localhost:4444",
options=options
)
driver.get("https://example.com")
driver.quit()
Remote execution is useful for Selenium Grid and distributed test environments.
pytest is a popular Python testing framework that can be used to organize and execute Selenium tests.
import pytest
from selenium import webdriver
def test_homepage():
driver = webdriver.Chrome()
try:
driver.get("https://example.com")
assert "Example" in driver.title
finally:
driver.quit()
pip install pytestpytestPython's built-in unittest framework can also be used to organize Selenium tests.
import unittest
from selenium import webdriver
class LoginTest(unittest.TestCase):
def setUp(self):
self.driver = webdriver.Chrome()
def test_homepage(self):
self.driver.get("https://example.com")
self.assertIn("Example", self.driver.title)
def tearDown(self):
self.driver.quit()
if __name__ == "__main__":
unittest.main()
Page Object Model (POM) is a design pattern commonly used to organize Selenium automation code. Each web page or major page component can be represented by a Python class.
from selenium.webdriver.common.by import By
class LoginPage:
def __init__(self, driver):
self.driver = driver
self.username = (By.ID, "username")
self.password = (By.ID, "password")
self.login_button = (By.ID, "login")
def login(self, username, password):
self.driver.find_element(*self.username).send_keys(username)
self.driver.find_element(*self.password).send_keys(password)
self.driver.find_element(*self.login_button).click()
POM separates page-specific element locators and actions from test logic, improving maintainability and reuse.
Data-driven testing executes the same test scenario with multiple sets of test data.
test_data = [
("user1", "Test@123"),
("user2", "Test@456"),
("user3", "Test@789")
]
for username, password in test_data:
print(username, password)
Test data can also be stored in CSV, JSON, Excel, databases, or other external sources.
A requirements.txt file can be used to record Python project dependencies.
selenium
pytest
Install project dependencies using:
pip install -r requirements.txtThe installed Selenium package can be checked using pip.
pip show seleniumAnother option is:
pip listThe Selenium version can be checked directly from Python.
import selenium
print(selenium.__version__)
Modern Selenium versions include Selenium Manager to assist with browser driver management. This reduces the need for manually downloading and configuring browser drivers in many standard setups.
The basic WebDriver creation can therefore remain simple:
from selenium import webdriver
driver = webdriver.Chrome()
driver.get("https://example.com")
driver.quit()
| Error | Possible Cause | Possible Solution |
|---|---|---|
| NoSuchElementException | Element cannot be located. | Check locator and page state. |
| TimeoutException | Expected condition was not met. | Review wait condition and timeout. |
| ElementNotInteractableException | Element cannot currently be interacted with. | Wait for visibility or usability. |
| ElementClickInterceptedException | Another element blocks the click. | Wait for overlays or use an appropriate interaction strategy. |
| StaleElementReferenceException | Element reference is no longer valid. | Locate the element again. |
| InvalidSelectorException | Locator syntax is invalid. | Correct the CSS or XPath selector. |
| WebDriverException | General WebDriver-related problem. | Check browser, driver, configuration, and environment. |
The following example demonstrates a basic end-to-end Selenium workflow.
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
driver = webdriver.Chrome()
try:
driver.get("https://example.com")
print("Title:", driver.title)
print("URL:", driver.current_url)
wait = WebDriverWait(driver, 10)
element = wait.until(
EC.presence_of_element_located((By.TAG_NAME, "body"))
)
print("Page text:")
print(element.text)
finally:
driver.quit()
selenium_project/
|
+-- tests/
| +-- test_login.py
| +-- test_search.py
|
+-- pages/
| +-- login_page.py
| +-- home_page.py
|
+-- utilities/
| +-- config.py
| +-- test_data.py
|
+-- screenshots/
|
+-- reports/
|
+-- requirements.txt
|
+-- pytest.ini
|
+-- README.md
This type of structure helps separate tests, page objects, reusable utilities, test data, screenshots, and reports.
driver.quit() for complete browser cleanup.Python Fundamentals
|
v
Selenium Installation
|
v
WebDriver Basics
|
v
Browser Automation
|
v
Locators
|
v
WebElement Operations
|
v
Waits and Synchronization
|
v
Alerts / Frames / Windows
|
v
Mouse and Keyboard Actions
|
v
pytest / unittest
|
v
Page Object Model
|
v
Data-Driven Testing
|
v
Reporting and Debugging
|
v
Automation Framework
|
v
CI/CD and Advanced Automation
| WebDriver Automation | Manual Testing |
|---|---|
| Tests are executed through automation scripts. | Tester manually performs test steps. |
| Useful for repetitive scenarios. | Useful for exploratory and human-centered testing. |
| Tests can be repeated consistently. | Execution depends on manual effort. |
| Requires programming and automation maintenance. | Requires test execution and domain knowledge. |
| Can be integrated into automated pipelines. | Manual execution is generally not directly automated. |
| Python | Java |
|---|---|
| Concise syntax. | More verbose syntax. |
| Easy to learn for beginners. | Strong enterprise ecosystem. |
| Works with pytest and unittest. | Commonly works with TestNG and JUnit. |
| Fast script development. | Strong object-oriented programming ecosystem. |
| Large automation and scripting ecosystem. | Widely used in enterprise automation environments. |
Create a Selenium Python program that performs the following steps:
Launch Browser
|
v
Open Website
|
v
Locate Element
|
v
Enter Data
|
v
Click Button
|
v
Wait for Result
|
v
Validate Result
|
v
Take Screenshot
|
v
Quit Browser
A beginner-friendly Selenium project is an automated login test. The project can validate that a user can enter credentials, submit the login form, and reach the expected page.
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
driver = webdriver.Chrome()
try:
driver.get("https://example.com/login")
username = driver.find_element(By.ID, "username")
password = driver.find_element(By.ID, "password")
username.send_keys("testuser")
password.send_keys("Test@123")
login_button = WebDriverWait(driver, 10).until(
EC.element_to_be_clickable((By.ID, "login"))
)
login_button.click()
print("Login test executed successfully.")
finally:
driver.quit()
Selenium WebDriver is a browser automation technology that allows programs to control web browsers and automate web application interactions.
Python provides simple syntax, rapid development, strong testing libraries, and an extensive ecosystem for automation.
from selenium import webdriver
driver = webdriver.Chrome()
driver.get("https://example.com")find_element() returns one matching element, while find_elements() returns a collection of matching elements.
The By class provides locator strategies such as ID, NAME, CSS_SELECTOR, XPATH, and CLASS_NAME.
An explicit wait waits for a specific condition before continuing the test.
Page Object Model is a design pattern that separates page-specific elements and actions from test logic.
close() closes the current browser window or tab, while quit() terminates the WebDriver session and closes associated browser windows.
driver.save_screenshot("screenshot.png")| Concept | Syntax / Example |
|---|---|
| Import WebDriver | from selenium import webdriver |
| Create Chrome | webdriver.Chrome() |
| Open URL | driver.get(url) |
| Find Element | driver.find_element() |
| Find Multiple Elements | driver.find_elements() |
| Locator | By.ID / By.NAME / By.XPATH / By.CSS_SELECTOR |
| Enter Text | element.send_keys() |
| Click | element.click() |
| Clear | element.clear() |
| Back | driver.back() |
| Forward | driver.forward() |
| Refresh | driver.refresh() |
| Wait | WebDriverWait() |
| Mouse Action | ActionChains() |
| Dropdown | Select() |
| Alert | driver.switch_to.alert |
| Frame | driver.switch_to.frame() |
| Screenshot | driver.save_screenshot() |
| Cookies | driver.get_cookies() |
| JavaScript | driver.execute_script() |
| Close Session | driver.quit() |
WebDriver with Python combines Python programming with Selenium's browser automation capabilities. It allows testers and developers to automate web applications, locate and interact with web elements, navigate between pages, handle dynamic content, work with alerts, frames and windows, perform mouse and keyboard operations, take screenshots, manage cookies, and execute JavaScript when necessary.
A strong Selenium Python automation skill set includes Python fundamentals, WebDriver, locators, WebElement methods, waits, exception handling, browser interactions, pytest or unittest, Page Object Model, data-driven testing, project structure, reporting, debugging, Git, and CI/CD concepts.
For practical learning and structured Selenium training, visit JustAcademy Selenium Training and use the Selenium Course Demo Registration page.
